import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Sort {
    /**
     * 判断是不是子单词
     * @param S
     * @param T
     * @return
     */
    public boolean isSubsequence (String S, String T) {
        // 思路：分别把S和T放进两个队列里，如果在分别遍历两个队列

        Queue<Character> queueS = new LinkedList<>();
        Queue<Character> queueT = new LinkedList<>();

        //分别把S和T放进两个队列里
        for(char ch : S.toCharArray()) {
            queueS.offer(ch);
        }
        for(char ch : T.toCharArray()) {
            queueT.offer(ch);
        }

        while (!queueS.isEmpty()) {
            char tmp = queueS.poll();
            //把T的队列全部出到一个新的数组中，遍历这个数组元素和tmp是否相同
            char[] ch = new char[queueT.size()];
            int index = 0;
            while (!queueT.isEmpty()) {
                ch[index] = queueT.poll();
                index++;
            }
            //遍历ch数组，用flag记录要使用ch的下标
            int flag = 0;
            for(int i = flag; i < ch.length; i++) {
                if(tmp == ch[i]) {
                    flag++;
                    break;
                }
                //不相等就自动往后遍历
                //queueS队列不为空，但是ch已经遍历完了，说明当前queueS队列队顶元素在ch数组中没有，返回false
                if(!queueS.isEmpty() && i == ch.length) {
                    return false;
                }
            }
        }
        //出来后S的队列为空了，返回true
        if(queueS.isEmpty()) {
            return true;
        }
        return false;
    }

    public static void main1(String[] args) {
        /**
         * 去重
         */
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        char[] ch = new char[0];
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            ch = in.nextLine().toCharArray();
        }
        //遍历ch字符串，把ch字符串数组放进栈里，除第一次，每放进一个元素前都要和栈顶元素比较，如果两元素相同，
        // 这个元素不放进去，同时栈顶也要出去，直到遍历完这个ch字符串，如果栈里还有元素，那这些元素就是我们的最终要的结果，
        // 不过还要倒置一下，没有，就是0
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < ch.length; i++) {
            //不是第一个元素，判断该元素和栈顶元素是否相同
            char tmp = 0;
            if(!stack.isEmpty()) {
               tmp = stack.peek();
            }

            if(i == 0 || tmp != ch[i]) {
                stack.add(ch[i]);
            } else {
                //tmp == ch[i]，不入栈，并且要出栈顶元素
                stack.pop();
            }
        }
        //看栈里还有多少元素，把这些元素全部放进新字符串数组中，并且要逆序着放
        int count = stack.size();
        char[] newCh = new char[count];

        //遍历完字符串了，现在判断栈里是否还有元素
        if(stack.size() == 0) {
            System.out.println(0);
        } else {
            //栈里还有元素
            for (int i = newCh.length - 1; i >= 0; i--) {
                newCh[i] = stack.pop();
            }
        }
        //遍历新数组
        for (char ch1:newCh) {
            System.out.print(ch1 + " ");
        }
    }
}